package com.aijk.commons.dict;

import com.aijk.commons.group.GroupResult;
import com.aijk.commons.group.GroupResults;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 数据字典初始化
 * Created by iscdw on 2016/4/12.
 */
@Service
public class DictService {

    private static final Logger logger = LoggerFactory.getLogger(DictService.class);

    @Resource(name = "loadDictService")
    private LoadDictService loadDictService;

    /**
     * 字典加载容器
     */
    public static final Map<String, DictDir> dicts = new HashMap<>();

    /**
     * 初始化字典，系统运行后立即执行
     */
    @PostConstruct
    public void init() {
        logger.info("加载数据字典服务...begin");
        List<Dict> list = loadDictService.load();
        DictGrouper grouper = new DictGrouper(list);
        GroupResults<String, Dict> results = grouper.group();

        for (GroupResult<String, Dict> result : results.getGroupResults()) {

            DictDir dictDir = new DictDir();
            Map<String, Dict> iidMap = new HashMap<>();
            Map<String, Dict> gbMap = new HashMap<>();
            for (Dict dict : result.getResults()) {
                iidMap.put(dict.getIid(), dict);
                gbMap.put(dict.getGbcode(), dict);
            }
            dictDir.setGbDict(gbMap);
            dictDir.setIidDict(iidMap);

            dicts.put(result.getKey(), dictDir);
            logger.info("  加载字典[cid={}]", result.getKey());
        }

        logger.info("加载数据字典服务...end");
    }

    /**
     * 根据字典类别 获取字典列表
     *
     * @param cid
     * @return
     */
    public List<Dict> getDictList(String cid) {
        return loadDictService.getDictList(cid);
    }

    /**
     * 根据字典类别 获取字典目录
     *
     * @param cid 字典类别
     * @return
     */
    public DictDir getDict(String cid) {
        return dicts.get(cid);
    }

    /**
     * 根据字典类别和字典代码获取字典信息
     *
     * @param cid 字典类别
     * @param iid 字典代码
     * @return
     */
    public Dict getDict(String cid, String iid) {
        return getDict(cid).getIidDict().get(iid);
    }

    /**
     * 根据字典类别和GB代码获取字典信息
     *
     * @param cid    字典类别
     * @param gbcode GB代码
     * @return
     */
    public Dict getDictByGb(String cid, String gbcode) {
        return getDict(cid).getGbDict().get(gbcode);
    }

    /**
     * 根据字典类别和GB代码获取字典代码
     *
     * @param cid    字典类别
     * @param gbcode GB代码
     * @return
     */
    public String getIidByGb(String cid, String gbcode) {
        return getDict(cid, gbcode).getIid();
    }

    /**
     * 根据字典类别和字典代码获取GB代码
     *
     * @param cid 字典类别
     * @param iid 字典代码
     * @return
     */
    public String getGbByIid(String cid, String iid) {
        return getDict(cid, iid).getGbcode();
    }

    /**
     * 根据字典类别和字典代码获取代码名称
     *
     * @param cid 字典类别
     * @param iid 字典代码
     * @return
     */
    public String getTitleByIid(String cid, String iid) {
        return getDict(cid, iid).getTitle();
    }

    /**
     * 根据字典类别和GB代码获取代码名称
     *
     * @param cid    字典类别
     * @param gbcode GB代码
     * @return
     */
    public String getTitleByGb(String cid, String gbcode) {
        return getDictByGb(cid, gbcode).getTitle();
    }

    /**
     * 判断字典类别和字典代码是否存在
     *
     * @param cid 字典类别
     * @param iid 字典代码
     * @return
     */
    public boolean containsIidKey(String cid, String iid) {
        DictDir dictDir = getDict(cid);
        if (dictDir == null) {
            return false;
        }
        return dictDir.getIidDict().containsKey(iid);
    }

    /**
     * 判断字段类别和GB代码是否存在
     *
     * @param cid    字典类别
     * @param gbcode GB代码
     * @return
     */
    public boolean containsGBKey(String cid, String gbcode) {
        DictDir dictDir = getDict(cid);
        if (dictDir == null) {
            return false;
        }
        return dictDir.getGbDict().containsKey(gbcode);
    }

}
